home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #5 & #6 / Amiga Plus CD - 1995 - No. 5 and 6.iso / pd / netz / term / extras / source / term-source.lha / termTraps.c < prev    next >
C/C++ Source or Header  |  1995-02-07  |  8KB  |  413 lines
  1. /*
  2. **    termTraps.c
  3. **
  4. **    Trap routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. struct TrapNode * __regargs
  13. ChangeTrapNode(struct GenericList *TrapList,struct TrapNode *Current,STRPTR Sequence,STRPTR Command)
  14. {
  15.     struct TrapNode *New;
  16.  
  17.     if(!Sequence)
  18.         Sequence = Current -> Node . ln_Name;
  19.  
  20.     if(!Command)
  21.         Command = Current -> Command;
  22.  
  23.     if(New = CreateTrapNode(Sequence,Command))
  24.     {
  25.         Insert((struct List *)TrapList,(struct Node *)New,(struct Node *)Current);
  26.  
  27.         Remove((struct Node *)Current);
  28.  
  29.         FreeVecPooled(Current);
  30.  
  31.         return(New);
  32.     }
  33.     else
  34.         return(Current);
  35. }
  36.  
  37. struct TrapNode * __regargs
  38. CreateTrapNode(STRPTR SequenceBuffer,STRPTR CommandBuffer)
  39. {
  40.     UBYTE         LocalBuffer[256];
  41.     LONG         Len = TranslateString(SequenceBuffer,LocalBuffer);
  42.     struct TrapNode    *Node;
  43.  
  44.     if(Node = (struct TrapNode *)AllocVecPooled(sizeof(struct TrapNode) + strlen(SequenceBuffer) + 1 + Len + strlen(CommandBuffer) + 1,MEMF_ANY))
  45.     {
  46.         STRPTR String;
  47.  
  48.         String = Node -> Node . ln_Name = (STRPTR)(Node + 1);
  49.  
  50.         strcpy(String,SequenceBuffer);
  51.  
  52.         String += strlen(String) + 1;
  53.  
  54.         Node -> Sequence = String;
  55.  
  56.         CopyMem(LocalBuffer,String,Len);
  57.  
  58.         String += Len;
  59.  
  60.         Node -> Command = String;
  61.  
  62.         Node -> SequenceLen = Len;
  63.         Node -> Count = 0;
  64.  
  65.         strcpy(String,CommandBuffer);
  66.     }
  67.  
  68.     return(Node);
  69. }
  70.  
  71.     /* SaveTraps(STRPTR Name):
  72.      *
  73.      *    Save the trap list to a file.
  74.      */
  75.  
  76. BYTE __regargs
  77. SaveTraps(STRPTR Name,struct List *TrapList)
  78. {
  79.     struct IFFHandle    *Handle;
  80.     BYTE             Success = FALSE;
  81.     LONG             Error = 0;
  82.  
  83.     if(Handle = (struct IFFHandle *)AllocIFF())
  84.     {
  85.         if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  86.         {
  87.             InitIFFasDOS(Handle);
  88.  
  89.             if(!(Error = OpenIFF(Handle,IFFF_WRITE)))
  90.             {
  91.                 if(!(Error = PushChunk(Handle,ID_TERM,ID_CAT,IFFSIZE_UNKNOWN)))
  92.                 {
  93.                     Success = TRUE;
  94.  
  95.                     if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  96.                     {
  97.                         if(!(Error = PushChunk(Handle,0,ID_VERS,IFFSIZE_UNKNOWN)))
  98.                         {
  99.                             struct TermInfo TermInfo;
  100.  
  101.                             TermInfo . Version    = CONFIG_FILE_VERSION;
  102.                             TermInfo . Revision    = CONFIG_FILE_REVISION;
  103.  
  104.                             if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  105.                             {
  106.                                 if(Error = PopChunk(Handle))
  107.                                     Success = FALSE;
  108.                             }
  109.                             else
  110.                             {
  111.                                 Error = IoErr();
  112.  
  113.                                 Success = FALSE;
  114.                             }
  115.                         }
  116.                         else
  117.                             Success = FALSE;
  118.  
  119.                         if(Success)
  120.                         {
  121.                             if(!(Error = PushChunk(Handle,0,ID_TRST,sizeof(struct TrapSettings))))
  122.                             {
  123.                                 struct TrapSettings TrapSettings;
  124.  
  125.                                 memset(&TrapSettings,0,sizeof(TrapSettings));
  126.  
  127.                                 TrapSettings . Enabled = WatchTraps;
  128.  
  129.                                 if(WriteChunkBytes(Handle,&TrapSettings,sizeof(struct TrapSettings)) == sizeof(struct TrapSettings))
  130.                                 {
  131.                                     if(Error = PopChunk(Handle))
  132.                                         Success = FALSE;
  133.                                 }
  134.                                 else
  135.                                 {
  136.                                     Success = FALSE;
  137.  
  138.                                     Error = IoErr();
  139.                                 }
  140.                             }
  141.                             else
  142.                                 Success = FALSE;
  143.                         }
  144.  
  145.                         if(Success)
  146.                         {
  147.                             if(Error = PopChunk(Handle))
  148.                                 Success = FALSE;
  149.                         }
  150.                     }
  151.                     else
  152.                         Success = FALSE;
  153.  
  154.                     if(Success)
  155.                     {
  156.                         struct TrapNode *Node;
  157.  
  158.                         Node = (struct TrapNode *)TrapList -> lh_Head;
  159.  
  160.                         while(Success && Node -> Node . ln_Succ)
  161.                         {
  162.                             if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  163.                             {
  164.                                 if(!(Error = PushChunk(Handle,0,ID_SEQN,strlen(Node -> Node . ln_Name))))
  165.                                 {
  166.                                     if(WriteChunkBytes(Handle,Node -> Node . ln_Name,strlen(Node -> Node . ln_Name)) != strlen(Node -> Node . ln_Name))
  167.                                     {
  168.                                         Error = IoErr();
  169.  
  170.                                         Success = FALSE;
  171.  
  172.                                         break;
  173.                                     }
  174.                                     else
  175.                                     {
  176.                                         if(Error = PopChunk(Handle))
  177.                                         {
  178.                                             Success = FALSE;
  179.  
  180.                                             break;
  181.                                         }
  182.                                         else
  183.                                         {
  184.                                             if(!(Error = PushChunk(Handle,0,ID_TRAP,strlen(Node -> Command))))
  185.                                             {
  186.                                                 if(WriteChunkBytes(Handle,Node -> Command,strlen(Node -> Command)) != strlen(Node -> Command))
  187.                                                 {
  188.                                                     Error = IoErr();
  189.  
  190.                                                     Success = FALSE;
  191.  
  192.                                                     break;
  193.                                                 }
  194.                                                 else
  195.                                                 {
  196.                                                     if(Error = PopChunk(Handle))
  197.                                                     {
  198.                                                         Success = FALSE;
  199.  
  200.                                                         break;
  201.                                                     }
  202.                                                 }
  203.                                             }
  204.                                         }
  205.                                     }
  206.                                 }
  207.  
  208.                                 if(Success)
  209.                                 {
  210.                                     if(Error = PopChunk(Handle))
  211.                                     {
  212.                                         Success = FALSE;
  213.  
  214.                                         break;
  215.                                     }
  216.                                 }
  217.                             }
  218.  
  219.                             Node = (struct TrapNode *)Node -> Node . ln_Succ;
  220.                         }
  221.                     }
  222.  
  223.                     if(Success)
  224.                     {
  225.                         if(Error = PopChunk(Handle))
  226.                             Success = FALSE;
  227.                     }
  228.                 }
  229.  
  230.                 CloseIFF(Handle);
  231.             }
  232.  
  233.             Close(Handle -> iff_Stream);
  234.         }
  235.         else
  236.             Error = IoErr();
  237.  
  238.         FreeIFF(Handle);
  239.     }
  240.     else
  241.         Error = ERR_NO_MEM;
  242.  
  243.     if(Success)
  244.         AddProtection(Name,FIBF_EXECUTE);
  245.     else
  246.         DeleteFile(Name);
  247.  
  248.     if(Error)
  249.         SetIoErr(Error);
  250.  
  251.     return(Success);
  252. }
  253.  
  254.     /* LoadTraps(STRPTR Name):
  255.      *
  256.      *    Restore the trap list from a file.
  257.      */
  258.  
  259. BYTE __regargs
  260. LoadTraps(STRPTR Name,struct GenericList *TrapList)
  261. {
  262.     STATIC ULONG Stops[8] =
  263.     {
  264.         ID_TERM,ID_VERS,
  265.         ID_TERM,ID_SEQN,
  266.         ID_TERM,ID_TRAP,
  267.         ID_TERM,ID_TRST
  268.     };
  269.  
  270.     struct IFFHandle    *Handle;
  271.     BYTE             Success = FALSE;
  272.     struct ContextNode    *Chunk;
  273.     LONG             Error = 0;
  274.     UBYTE             SequenceBuffer[256],
  275.                  CommandBuffer[256];
  276.     struct TrapSettings     TrapSettings;
  277.     BYTE             TrapSettingsFound = FALSE;
  278.  
  279.     if(Handle = AllocIFF())
  280.     {
  281.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  282.         {
  283.             InitIFFasDOS(Handle);
  284.  
  285.             if(!(Error = OpenIFF(Handle,IFFF_READ)))
  286.             {
  287.                 if(!(Error = StopChunks(Handle,(LONG *)Stops,4)))
  288.                 {
  289.                     Success = TRUE;
  290.  
  291.                     SequenceBuffer[0] = CommandBuffer[0] = 0;
  292.  
  293.                     while(!ParseIFF(Handle,IFFPARSE_SCAN))
  294.                     {
  295.                         Chunk = CurrentChunk(Handle);
  296.  
  297.                         if(Chunk -> cn_ID == ID_VERS)
  298.                         {
  299.                             struct TermInfo TermInfo;
  300.  
  301.                             if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  302.                             {
  303.                                 if((TermInfo . Version > CONFIG_FILE_VERSION) || (TermInfo . Version == CONFIG_FILE_VERSION && TermInfo . Revision > CONFIG_FILE_REVISION) || (TermInfo . Version == 1 && TermInfo . Revision < 6))
  304.                                 {
  305.                                     Error = ERR_OUTDATED;
  306.  
  307.                                     break;
  308.                                 }
  309.                             }
  310.                             else
  311.                             {
  312.                                 Success = FALSE;
  313.  
  314.                                 Error = IoErr();
  315.  
  316.                                 break;
  317.                             }
  318.                         }
  319.  
  320.                         if(Chunk -> cn_ID == ID_TRST)
  321.                         {
  322.                             if(ReadChunkBytes(Handle,&TrapSettings,sizeof(struct TrapSettings)) == sizeof(struct TrapSettings))
  323.                                 TrapSettingsFound = TRUE;
  324.                             else
  325.                             {
  326.                                 Success = FALSE;
  327.  
  328.                                 Error = IoErr();
  329.  
  330.                                 break;
  331.                             }
  332.                         }
  333.  
  334.                         if(Chunk -> cn_ID == ID_SEQN)
  335.                         {
  336.                             if(ReadChunkBytes(Handle,SequenceBuffer,Chunk -> cn_Size) == Chunk -> cn_Size)
  337.                                 SequenceBuffer[Chunk -> cn_Size] = 0;
  338.                             else
  339.                             {
  340.                                 Success = FALSE;
  341.  
  342.                                 Error = IoErr();
  343.  
  344.                                 break;
  345.                             }
  346.                         }
  347.  
  348.                         if(Chunk -> cn_ID == ID_TRAP)
  349.                         {
  350.                             if(ReadChunkBytes(Handle,CommandBuffer,Chunk -> cn_Size) == Chunk -> cn_Size)
  351.                                 CommandBuffer[Chunk -> cn_Size] = 0;
  352.                             else
  353.                             {
  354.                                 Success = FALSE;
  355.  
  356.                                 Error = IoErr();
  357.  
  358.                                 break;
  359.                             }
  360.                         }
  361.  
  362.                         if(Success && SequenceBuffer[0] && CommandBuffer[0])
  363.                         {
  364.                             struct TrapNode *Node;
  365.  
  366.                             if(Node = CreateTrapNode(SequenceBuffer,CommandBuffer))
  367.                             {
  368.                                 AddGenericListNode(TrapList,(struct Node *)Node,ADD_GLIST_BOTTOM);
  369.  
  370.                                 SequenceBuffer[0] = CommandBuffer[0] = 0;
  371.                             }
  372.                             else
  373.                             {
  374.                                 Success = FALSE;
  375.  
  376.                                 Error = ERR_NO_MEM;
  377.  
  378.                                 break;
  379.                             }
  380.                         }
  381.                     }
  382.                 }
  383.  
  384.                 CloseIFF(Handle);
  385.             }
  386.  
  387.             Close(Handle -> iff_Stream);
  388.         }
  389.         else
  390.             Error = IoErr();
  391.  
  392.         FreeIFF(Handle);
  393.     }
  394.     else
  395.         Error = ERR_NO_MEM;
  396.  
  397.     if(Error)
  398.         SetIoErr(Error);
  399.  
  400.     if(Success)
  401.     {
  402.         TrapsChanged = FALSE;
  403.  
  404.         if(TrapSettingsFound)
  405.             WatchTraps = TrapSettings . Enabled;
  406.     }
  407.  
  408.     if(!TrapList -> ListCount && WatchTraps)
  409.         WatchTraps = FALSE;
  410.  
  411.     return(Success);
  412. }
  413.